package com.zelix;

import java.io.PrintWriter;
import java.util.*;

public class yc
        implements wg {

    protected Vector a;
    protected nh b;
    protected PrintWriter c;
    protected it d;
    protected Hashtable e;
    protected Hashtable f;
    protected Hashtable g;
    protected Hashtable h;
    protected Hashtable i;
    protected Hashtable j;

    public yc(it it1, Vector vector, nh nh1) {
        d = it1;
        a = vector;
        b = nh1;
        c = nh1.n();
    }

    public final boolean a() {
        return e.size() == 0;
    }

    public final boolean b() {
        return f.size() == 0;
    }

    public boolean c() {
        return i.size() == 0;
    }

    public Enumeration a(String s) {
        return d.c(s);
    }

    public final Enumeration b(String s) {
        Enumeration enumeration = d.d(s);
        if (enumeration == null)
            return null;
        else
            return enumeration;
    }

    public final boolean a(String s, String s1)
            throws wb {
        return d.a(s, s1);
    }

    public final boolean b(String s, String s1)
            throws wb {
        return d.b(s, s1);
    }

    public final Enumeration e() {
        mt amt[];
        Enumeration enumeration;
        int k;
        amt = new mt[f.size()];
        enumeration = f.keys();
        k = 0;
        while (enumeration.hasMoreElements()) {
            amt[k++] = (mt) enumeration.nextElement();
        }
        return new cv(amt);
    }

    public Enumeration f() {
        lu alu[];
        Enumeration enumeration;
        int k;
        alu = new lu[j.size()];
        enumeration = j.keys();
        k = 0;
        while (enumeration.hasMoreElements()) {
            alu[k++] = (lu) enumeration.nextElement();
        }
        return new cv(alu);
    }

    public Enumeration g() {
        ou aou[];
        Enumeration enumeration;
        int k;
        aou = new ou[h.size()];
        enumeration = h.keys();
        k = 0;
        while (enumeration.hasMoreElements()) {
            aou[k++] = (ou) enumeration.nextElement();
        }
        return new cv(aou);
    }

    public final Enumeration h() {
        mt amt[];
        Enumeration enumeration;
        int k;
        amt = new mt[e.size()];
        enumeration = e.keys();
        k = 0;
        while (enumeration.hasMoreElements()) {
            amt[k++] = (mt) enumeration.nextElement();
        }
        return new cv(amt);
    }

    public Enumeration i() {
        lu alu[];
        Enumeration enumeration;
        int k;
        alu = new lu[i.size()];
        k = 0;
        enumeration = i.keys();
        while (enumeration.hasMoreElements()) {
            alu[k++] = (lu) enumeration.nextElement();
        }
        return new cv(alu);
    }

    public Enumeration j() {
        ou aou[];
        Enumeration enumeration;
        int k;
        aou = new ou[g.size()];
        enumeration = g.keys();
        k = 0;
        while (enumeration.hasMoreElements()) {
            aou[k++] = (ou) enumeration.nextElement();
        }
        return new cv(aou);
    }

    public final boolean a(mt mt1) {
        return f.containsKey(mt1);
    }

    public final boolean c(String s) {
        fh fh1 = fh.b(s);
        if (fh1 != null) {
            mt mt1 = fh1.c();
            return f.containsKey(mt1);
        } else {
            return false;
        }
    }

    public final boolean c(mt mt1) {
        return e.containsKey(mt1);
    }

    public boolean a(lu lu1) {
        return j.containsKey(lu1);
    }

    public boolean a(ou ou1) {
        return h.containsKey(ou1);
    }
}
